package com.binc.testspring.common.lamada;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author binc
 *  Comparator 比较器学习  一：SortTest： 利用comparator 实现排序
 *                      二： GroupTest 利用comparator 实现分组  （这个卸载另一个类中了）
 *
 *
 */
public class SortTest {
    public SortTest() {
    }

    /**
     * 循序渐进学习
     * @param args
     */
    public static void main(String[] args) {
        List<Dog> list= new ArrayList<>();
        list.add(new Dog(5, "DogA"));
        list.add(new Dog(6, "DogB"));
        list.add(new Dog(7, "DogC"));

        // 0 原始写法  Collections.sort排序需要一个Comparator对象，我们就创建了整么一个对象（DogComparator）
        DogComparator dogComparator = new DogComparator();// 这是一个按照狗年龄倒叙的比较器
        Collections.sort(list,dogComparator);
        System.out.println("----- 0 原始写法,创建比较器对象：倒叙："+list);

        // 0->1 我们不用真实创建比较器类，我们用匿名内部类，并重写特定方法
        Collections.sort(list, new Comparator<Dog>() {
            @Override
            public int compare(Dog o1, Dog o2) {
                return o2.age - o1.age;  // 默认是 形参1 - 形参2   正序    ； 这里是形参2 - 形参1   倒叙
            }
        });
        System.out.println("----- 1 我们不用真实创建比较器类，我们用匿名内部类，并重写特定方法：倒序："+list);

        // 1->2 匿名内部类用lamada表达式替换   [年龄 正序]
                                                //  两个入参，一个返回值的函数式接口
        List<Dog> collect = list.stream().sorted((a1, a2) -> a1.getAge() - a2.getAge() ).collect(Collectors.toList());
        System.out.println("----- 2 匿名内部类用lamada表达式替换   [年龄 正序] ："+collect);

        /*
           2-> 3 lamada表达式还能继续简化（因为Comparator接口中有一个实现方法，comparingInt（），
                这个方法的作用就是 Funcation表达式(一个参数，一个返回值)，他返回一个这样的玩意儿
                (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2))）  即一个Comparator<T>对象（sorted需要的正好也就是要给Comparator对象）

                    public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
                        Objects.requireNonNull(keyExtractor);
                        return (Comparator<T> & Serializable)
                            (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
                    }

                这个方法返回的就是一个我们上一步骤填写的lamada表达是的内容，所有  comparingInt 等于是jdk为我们提供的共方便的现成的实现；
                类似的实现还有  comparingLong  comparingDouble  comparingInt 等
         */
        List<Dog> collect_3 = list.stream().sorted(Comparator.comparingInt(Dog::getAge)).collect(Collectors.toList());
        System.out.println("年龄 正序---"+collect_3);

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



        // 1.2 演示正序
        Collections.sort(list, new Comparator<Dog>() {

            @Override
            public int compare(Dog o1, Dog o2) {
                return o1.age - o2.age;  // 默认是 形参1 - 形参2   正序
            }
        });
        System.out.println("给狗狗按照年龄正序："+list);
        System.out.println("=============================================");
/**
 * 别的比较规则
 */
        // 演示别的比较规则
        Collections.sort(list, new Comparator<Dog>() {

            @Override
            public int compare(Dog o1, Dog o2) {
                return o1.name.compareTo(o2.name);
            }
        });
        System.out.println("给狗狗按名字字母顺序排序："+list);

/**
 *  自定义比较属性   即正序 倒序
 *    以后只写这两种就行了
 */
        List<Dog> collect1 = list.stream().sorted(Comparator.comparing(Dog::getName)).collect(Collectors.toList());
        System.out.println("给狗狗按名字字母顺序排序："+collect1);


        List<Dog> collect2 = list.stream().sorted(Comparator.comparing(Dog::getName).reversed()).collect(Collectors.toList());
        System.out.println("给狗狗按名字字母顺序排序(倒叙)："+collect2);


        System.out.println("=============================================");
    }



}

class Dog{
    public int age;
    public String name;

    public int getAge() {
        return age;
    }

    public Dog setAge(int age) {
        this.age = age;
        return this;
    }

    public String getName() {
        return name;
    }

    public Dog setName(String name) {
        this.name = name;
        return this;
    }

    public Dog(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Dog [age=" + age + ", name=" + name + "]";
    }
}





    /**
     * 自定义个一个按照狗年龄倒叙的比较器
     *  关键：实现Comparator接口，实现compare接口
     */
    class DogComparator implements  Comparator<Dog>{
        public DogComparator() {
        }

        //实现的方式是按照倒序排列的
        @Override
        public int compare(Dog o1, Dog o2) {
            return o2.getAge() - o1.getAge();
        }
    }
